HAL FDCAN initialization and configuration functions migration

The goal of this page is to show how to migrate the initialization sequence using STM32CubeMX2:

  • Open STM32CubeMX2 FDCAN configuration panel.

  • Configure the SW layer HAL.

  • Configure the FDCAN main features.

  • Configure the additional FDCAN features if needed.

  • Configure the FDCAN GPIO pins.

  • Configure the FDCAN DMA(s) if the application requires to use the FDCAN in DMA mode.

  • Configure the NVIC if the application requires the FDCAN to be used in IT mode.

  • Generate the code.

HAL FDCAN configuration panel

Create a new project with the STM32CubeMX2, then start the initialization and configuration.

  • Select the appropriate FDCAN to begin the configuration process.

Project configuration panel

Configure the FDCAN main features

Configure the main features configuration of the FDCAN.

FDCAN main feature configuration

Configure the FDCAN additional features

Configure the additional feature configuration of the FDCAN if needed.

FDCAN additional feature configuration

GPIO configuration

Configure the FDCAN receive and transmit pins.

FDCAN GPIO configuration

NVIC configuration

Configure the NVIC Line.

FDCAN NVIC configuration

HAL FDCAN generated initialization, setconfig and de-initialization sequences

The FDCAN initialization sequence is generated in the mx_fdcan1_init function in mx_fdcan1.c file under $YOUR_PROJECT_NAME$/$YOUR_PROJECT_NAME$_SW/generated/STM32Cube_CodeGen.

Related concepts:

STM32CubeMX2 Generated : FDCAN initialization sequence

Topic

HAL1 Code Snippet

HAL2 Code Snippet

FDCAN init, config and MSp sequences 

static void MX_FDCAN1_Init(void)
{



   hfdcan1.Instance = FDCAN1;









   hfdcan1.Init.NominalPrescaler = 16;
   hfdcan1.Init.NominalTimeSeg1 = 1;
   hfdcan1.Init.NominalTimeSeg2 = 1;
   hfdcan1.Init.NominalSyncJumpWidth = 1;




   hfdcan1.Init.ClockDivider = FDCAN_CLOCK_DIV1;
   hfdcan1.Init.FrameFormat = FDCAN_FRAME_CLASSIC;
   hfdcan1.Init.Mode = FDCAN_MODE_NORMAL;
   hfdcan1.Init.AutoRetransmission = DISABLE;
   hfdcan1.Init.TransmitPause = DISABLE;
   hfdcan1.Init.ProtocolException = DISABLE;
   hfdcan1.Init.StdFiltersNbr = 0;
   hfdcan1.Init.ExtFiltersNbr = 0;
   hfdcan1.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION;

   hfdcan1.Init.DataPrescaler = 1;
   hfdcan1.Init.DataSyncJumpWidth = 1;
   hfdcan1.Init.DataTimeSeg1 = 1;
   hfdcan1.Init.DataTimeSeg2 = 1;

   if (HAL_FDCAN_Init(&hfdcan1) != HAL_OK)
   {
     Error_Handler();
   }
 }





void HAL_FDCAN_MspInit(FDCAN_HandleTypeDef* hfdcan)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
  if(hfdcan->Instance==FDCAN1)
  {
    PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_FDCAN1;
    PeriphClkInit.Fdcan1ClockSelection = RCC_FDCAN1CLKSOURCE_PLL1;
    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_RCC_FDCAN1_CLK_ENABLE();

    __HAL_RCC_GPIOF_CLK_ENABLE();

    GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_8;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN1;
    HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
  }
}

hal_fdcan_handle_t *mx_fdcan1_init(void)
{
  hal_fdcan_config_t fdcan_config;

  HAL_RCC_FDCAN_EnableClock();
  if (HAL_FDCAN_Init(&hFDCAN1, HAL_FDCAN1) != HAL_OK)
  {
    return NULL;
  }

  if (HAL_RCC_FDCAN_SetKernelClkSource(HAL_RCC_FDCAN_CLK_SRC_PLL1Q) != HAL_OK)
  {
    return NULL;
  }

  hal_fdcan_nominal_bit_timing_t fdcan_nominal_bit_timing;
  fdcan_nominal_bit_timing.nominal_prescaler  = 16;
  fdcan_nominal_bit_timing.nominal_time_seg1  = 1;
  fdcan_nominal_bit_timing.nominal_time_seg2  = 1;
  fdcan_nominal_bit_timing.nominal_jump_width = 1;

  fdcan_config.nominal_bit_timing   = fdcan_nominal_bit_timing;
  /* Data bit timing parameters are not used in Classic CAN or non-BRS modes */

  fdcan_config.frame_format         = HAL_FDCAN_FRAME_FORMAT_CLASSIC_CAN;
  fdcan_config.mode                 = HAL_FDCAN_MODE_NORMAL;
  fdcan_config.auto_retransmission  = HAL_FDCAN_AUTO_RETRANSMISSION_DISABLE;
  fdcan_config.transmit_pause       = HAL_FDCAN_TRANSMIT_PAUSE_DISABLE;
  fdcan_config.protocol_exception   = HAL_FDCAN_PROTOCOL_EXCEPTION_DISABLE;
  fdcan_config.std_filters_nbr      = 0;
  fdcan_config.ext_filters_nbr      = 0;
  fdcan_config.tx_fifo_queue_mode   = HAL_FDCAN_TX_MODE_FIFO;
  if (HAL_FDCAN_SetConfig(&hFDCAN1, &fdcan_config) != HAL_OK)
  {
    return NULL;
  }

  if (HAL_FDCAN_SetClockDivider(&hFDCAN1, HAL_FDCAN_CLOCK_DIV_1) != HAL_OK)
  {
    return NULL;
  }

  /* Configure the global filter acceptance/rejection rules */
  hal_fdcan_global_filter_config_t global_filter_cfg;
  global_filter_cfg.acceptance_non_matching_std = HAL_FDCAN_NO_MATCH_TO_RX_FIFO_0;
  global_filter_cfg.acceptance_non_matching_ext = HAL_FDCAN_NO_MATCH_TO_RX_FIFO_0;
  global_filter_cfg.acceptance_remote_std       = HAL_FDCAN_REMOTE_REJECT;
  global_filter_cfg.acceptance_remote_ext       = HAL_FDCAN_REMOTE_REJECT;
  if (HAL_FDCAN_SetGlobalFilter(&hFDCAN1, &global_filter_cfg) != HAL_OK)
  {
    return NULL;
  }
  HAL_RCC_GPIOF_EnableClock();











  hal_gpio_config_t  gpio_config;
  gpio_config.mode        = HAL_GPIO_MODE_ALTERNATE;
  gpio_config.output_type = HAL_GPIO_OUTPUT_PUSHPULL;
  gpio_config.pull        = HAL_GPIO_PULL_NO;
  gpio_config.speed       = HAL_GPIO_SPEED_FREQ_LOW;
  gpio_config.alternate   = HAL_GPIO_AF_9;
  HAL_GPIO_Init(HAL_GPIOF, HAL_GPIO_PIN_7 | HAL_GPIO_PIN_8, &gpio_config);

  return &hFDCAN1;
}

FDCAN deinit sequence 

void HAL_FDCAN_MspDeInit(FDCAN_HandleTypeDef* hfdcan)
{
  if(hfdcan->Instance==FDCAN1)
  {
    __HAL_RCC_FDCAN1_CLK_DISABLE();

    HAL_GPIO_DeInit(GPIOF, GPIO_PIN_7|GPIO_PIN_8);
  }

}

void mx_fdcan1_deinit(void)
{
  (void)HAL_FDCAN_DeInit(&hFDCAN1);

  HAL_GPIO_DeInit(HAL_GPIOF, HAL_GPIO_PIN_7);

  HAL_GPIO_DeInit(HAL_GPIOF, HAL_GPIO_PIN_8);

}